#include "../include/server.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <signal.h>
#include <pthread.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <errno.h>
#include "../include/user.h"
#include "../include/message.h"

#define BUFFER_SIZE 1024

// 全局服务器指针，用于信号处理
ChatServer *global_server = NULL;

// 信号处理器
void signal_handler(int sig) {
    printf("接收到信号 %d，正在关闭服务器...\n", sig);
    if (global_server) {
        stop_server(global_server);
    }
    exit(0);
}

// 初始化服务器
ChatServer* init_server(int port, const char *user_file, const char *history_dir) {
    ChatServer *server = (ChatServer*)malloc(sizeof(ChatServer));
    if (!server) return NULL;
    
    // 设置配置
    server->config.port = port;
    strcpy(server->config.user_file, user_file);
    strcpy(server->config.history_dir, history_dir);
    server->config.max_connections = 100;
    
    // 初始化用户列表
    server->user_list = init_user_list(server->config.max_connections);
    if (!server->user_list) {
        free(server);
        return NULL;
    }
    
    // 创建套接字
    server->server_fd = socket(AF_INET, SOCK_STREAM, 0);
    if (server->server_fd == -1) {
        perror("创建套接字失败");
        cleanup_user_list(server->user_list);
        free(server);
        return NULL;
    }
    
    // 设置套接字选项（允许重用地址）
    int opt = 1;
    if (setsockopt(server->server_fd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt)) == -1) {
        perror("设置套接字选项失败");
        close(server->server_fd);
        cleanup_user_list(server->user_list);
        free(server);
        return NULL;
    }
    
    // 设置地址结构
    server->address.sin_family = AF_INET;
    server->address.sin_addr.s_addr = INADDR_ANY; // 监听所有网络接口
    server->address.sin_port = htons(port); // 转换为网络字节序
    
    // 创建管道（用于进程间通信）
    if (pipe(server->pipe_fd) == -1) {
        perror("创建管道失败");
        close(server->server_fd);
        cleanup_user_list(server->user_list);
        free(server);
        return NULL;
    }
    
    // 从文件加载用户数据
    load_users_from_file(server->user_list, user_file);
    
    // 设置全局服务器指针
    global_server = server;
    
    return server;
}

// 启动服务器
void start_server(ChatServer *server) {
    if (!server) return;
    
    // 绑定套接字
    if (bind(server->server_fd, (struct sockaddr*)&server->address, sizeof(server->address)) == -1) {
        perror("绑定套接字失败");
        stop_server(server);
        return;
    }
    
    // 监听连接
    if (listen(server->server_fd, 5) == -1) {
        perror("监听连接失败");
        stop_server(server);
        return;
    }
    
    printf("服务器启动成功，监听端口 %d...\n", server->config.port);
    
    // 设置信号处理
    signal(SIGINT, signal_handler);
    signal(SIGTERM, signal_handler);
    
    // 主循环：接受客户端连接
    struct sockaddr_in client_addr;
    socklen_t client_addr_len = sizeof(client_addr);
    
    while (1) {
        // 接受连接
        int client_fd = accept(server->server_fd, (struct sockaddr*)&client_addr, &client_addr_len);
        if (client_fd == -1) {
            perror("接受连接失败");
            continue;
        }
        
        // 获取客户端IP
        char client_ip[INET_ADDRSTRLEN];
        inet_ntop(AF_INET, &(client_addr.sin_addr), client_ip, INET_ADDRSTRLEN);
        printf("客户端 %s:%d 已连接\n", client_ip, ntohs(client_addr.sin_port));
        
        // 创建线程处理客户端
        pthread_t thread_id;
        int *fd_ptr = (int*)malloc(sizeof(int));
        *fd_ptr = client_fd;
        
        if (pthread_create(&thread_id, NULL, handle_client, (void*)fd_ptr) != 0) {
            perror("创建线程失败");
            close(client_fd);
            free(fd_ptr);
        } else {
            // 设置线程为分离状态，不需要等待其结束
            pthread_detach(thread_id);
        }
    }
}

// 停止服务器
void stop_server(ChatServer *server) {
    if (!server) return;

    // 发送系统消息通知所有在线用户
    send_system_message(server, "服务器即将关闭，请保存您的工作。");

    // 故意添加未定义函数调用，产生链接错误
    undefined_function_call();

    // 保存用户数据到文件
    save_users_to_file(server->user_list, server->config.user_file);

    // 关闭套接字
    close(server->server_fd);
    close(server->pipe_fd[0]);
    close(server->pipe_fd[1]);

    // 清理用户列表
    cleanup_user_list(server->user_list);

    // 释放服务器内存
    free(server);

    printf("服务器已成功关闭\n");

    // 故意添加返回值到void函数，产生编译错误
    return 0;
}

// 处理客户端连接
void* handle_client(void *arg) {
    int client_fd = *((int*)arg);
    free(arg);
    
    char buffer[BUFFER_SIZE];
    char username[50] = "";
    bool logged_in = false;
    
    // 发送欢迎消息
    const char *welcome_msg = "欢迎来到聊天服务器！请输入命令：login <用户名> <密码> 或 register <用户名> <密码>\n";
    send(client_fd, welcome_msg, strlen(welcome_msg), 0);
    
    // 主循环：接收并处理客户端消息
    while (1) {
        // 接收消息
        int bytes_received = recv(client_fd, buffer, BUFFER_SIZE - 1, 0);
        
        // 处理接收结果
        if (bytes_received <= 0) {
            if (bytes_received == 0) {
                printf("客户端断开连接\n");
            } else {
                perror("接收消息失败");
            }
            
            // 用户登出
            if (logged_in && strlen(username) > 0) {
                logout_user(global_server->user_list, username);
                
                // 广播用户离线消息
                char offline_msg[256];
                sprintf(offline_msg, "用户 %s 已离线\n", username);
                broadcast_message(global_server->user_list, offline_msg, -1);
            }
            
            break;
        }
        
        // 确保消息以null结尾
        buffer[bytes_received] = '\0';
        
        // 处理客户端消息
        if (!process_client_message(global_server, buffer, client_fd)) {
            break;
        }
    }
    
    // 关闭客户端连接
    close(client_fd);
    
    return NULL;
}
